Method and system for implementing persistent object services on a relational database

ABSTRACT

A persistent object service (POS) that interfaces to a set of one or more relational database management systems. A persistent object is mapped to one or more tables in a relational database based on the object&#39;s attribute types and the object&#39;s relationships with other objects. If the object inherits from another object, the mapping creates multiple tables, a top level table for base attributes, and a set of one or more child tables that contain extended attributes of the inherited objects. A routine for storing an object converts persistent object operations to a sequence of SQL statements for storing the object in the relational database.

CROSS-REFERENCE TO RELATED APPLICATIONS

[0001] This is a divisional application of U.S. patent application Ser. No. 09/368,698, filed Aug. 5, 1999, titled “Implementing persistent object services (POS) on top of a relational database”.

BACKGROUND OF THE INVENTION

[0002] 1. Field of the Invention

[0003] This invention relates generally to database management. In particular, this invention relates to methods for mapping data between an object-oriented data model and a relational data model.

[0004] 2. Description of Related Art

[0005] A relational database management system (RDBMS) is a computer database management system that uses relational techniques for storing and retrieving data. Relational databases are computerized information storage and retrieval systems in which data in the form of tables (or relations) are typically stored for use on disk drives or similar mass datastores. A table includes a set of rows (or records) spanning several columns. Each column in a table typically includes restrictions on the data contents thereof. An RDBMS is structured to accept commands to store, retrieve and delete data using high-level query languages such as the Structured Query Language (SQL). A query denotes a set of commands for retrieving data from a stored database.

[0006] Object-oriented programming methodologies are also well-known in the prior art. Such methods focus on manipulating data rather than procedures. In an object-oriented paradigm, objects encapsulate related data and procedures to hide that information from the remainder of the program by allowing access to the data and procedures only through the object's interface. Thus, changes to the data or procedures of the object are relatively isolated from the remainder of the program.

[0007] An object-oriented computing environment typically includes an object-oriented database for storing data according to an object-oriented database schema. The object-oriented database schema specifies the information needed to define the classes and class hierarchy for the objects stored in the object-oriented database, such as the attributes for each class, the data type of each attribute, and the like. A given object may be transient or persistent. A persistent object is an object whose state can outlive the life of a specific instance of the object.

[0008] An object-oriented environment may be distributed across computers interconnected by a computer network. A distributed object refers to an encapsulated package of code and data that can be manipulated by operations through an interface. Distributed objects can be located anywhere in a network as clients or servers, depending upon whether they are sending requests to other objects or replying to requests from clients.

[0009] Given the popularity of relational databases as well the widespread implementation of object-oriented programming methods, it has become necessary to provide tools by which object-oriented applications can fetch data from relational databases. In response, the prior art has developed several different approaches to this problem. In one approach, as represented in U.S. Pat. Nos. 5,761,671, 5,794,247 and 5,794,248, to Blackman et al., commonly assigned to IBM, a bridge is used to translate data between object-oriented and non-object-oriented datastores. The bridge provides a datastore persistent object class to wrap or encapsulate data retrieved from the relational database, a queryable persistent identifier to specify information used to locate the data in the relational database needed to populate a given object, and a schema mapper class used to obtain the required data from the relational database and to translate or transfer it into the format of the particular requesting object.

[0010] Another approach to this problem is illustrated in U.S. Pat. No. 5,765,159, to Srinivasan, also assigned to IBM. This patent provides a method for processing object-oriented queries to retrieve data from a relational database. An object-oriented query and at least one prefetch path are received from an object-oriented program. The prefetch path identifies one or more objects that are desired to be constructed. The query is translated to a translated object query, which is a relational database query capable of retrieving from the RDBMS data to initialize base attributes of top-level objects identified by the query. A set of relational queries is generated from the translated object query and the prefetch path. These relational queries are processed by the RDBMS.

[0011] Still other approaches to the problem of mapping data between a relational format and an object-oriented format are described in several patents, including, U.S. Pat. No. 5,694,598 to Durand et al., U.S. Pat. No. 5,499,371 to Henninger et al., U.S. Pat. No. 5,734,887 to Kingberg et al., to name just a few. In Durand et al., which is a distributed object operating environment, the invention uses a special construct, a so-called transit object, for this purpose. In Henninger et al., the relational database interaction is controlled directly by the methods of the object class, e.g., using embedded SQL. Kingberg et al. use a logical data access layer to access the physical structure of a relational database.

[0012] Although the above-described patents all provide useful techniques for enabling object-oriented access to a relational database, there remains a need in the art to provide a persistent object service (POS) that can interface with all of the major different types of relational databases including, for example, Oracle, Sybase, MS-SQL Server, Informix and DB2. The present invention addresses this need in the art.

SUMMARY OF THE INVENTION

[0013] It is a general feature of the invention to map data between an object-oriented format and a relational format.

[0014] It is another general feature of this invention to provide a generic persistent object service (POS) that may interface to different and varied relational database management systems.

[0015] Another general feature of this invention is to map objects to one or more tables in a relational database based on the object's attribute types.

[0016] Still another feature of this invention to provide a novel mechanism for storing an object in a relational database, and for restoring that object from data retrieved from that database.

[0017] These and other features of the present invention are provided in a persistent object service (POS) that interfaces to a set of one or more relational database management systems. A persistent object, namely, an object whose state may outlive the life of a specific instance of the object, is mapped to one or more tables in a relational database based on the object's attribute types and the object's relationships with other objects. If the object inherits from another object, the mapping creates multiple tables, a top level table for base attributes, and a set of one or more child tables that contain extended attributes of the inherited objects. The service includes an object store routine for storing an object by converting persistent object operations to a sequence of SQL statements. The service also includes an object restore routine for re-generating the object by retrieving object attribute information from the relational tables.

[0018] The foregoing has outlined some of the more pertinent objects and features of the present invention. These objects should be construed to be merely illustrative of some of the more prominent features and applications of the invention. Many other beneficial results can be attained by applying the disclosed invention in a different manner or modifying the invention as will be described. Accordingly, other objects and a fuller understanding of the invention may be had by referring to the following Detailed Description of the Preferred Embodiment.

BRIEF DESCRIPTION OF THE DRAWINGS

[0019] For a more complete understanding of the present invention and the advantages thereof, reference should be made to the following Detailed Description taken in connection with the accompanying drawings in which:

[0020]FIG. 1 is a block diagram of an object-oriented computing environment according to a preferred embodiment of the present invention;

[0021]FIG. 2 is a block diagram of a computer system in which the computing environment of FIG. 1 resides;

[0022]FIG. 3 illustrates an example schema mapping;

[0023]FIG. 4 is a table generated by the schema mapping;

[0024]FIG. 5 is an illustrative example of the schema mapping;

[0025]FIG. 6 is a simplified flowchart of a routine for storing an object in the relational database; and

[0026]FIG. 7 is a simplified flowchart of a routine for restoring an object from data retrieved from the relational database.

DETAILED DESCRIPTION OF THE INVENTION

[0027]FIG. 1 is a block diagram of an object-oriented computing environment 102 in which the present invention may be implemented. The object-oriented computing environment includes at least one object-oriented database management system (DMBS) 110 that stores data according to an object-oriented database schema. The object-oriented database schema specifies the information needed to define the classes and the class hierarchy for the object stored in the object-oriented DMBS 110, such as the attributes for each class, the data type of each attribute, and the like.

[0028] The object-oriented computing environment 102 also includes one or more relational database management systems (RDBMS) 112 a-112 n. The RDBMS 112 can also be viewed at outside of the object-oriented computing environment 102, but physically connected to components in the object-oriented computing environment 102 (in particular, to a gateway 106). A suitable form of the RDBMS 112 is DB2 for AIX/6000 Version 2, DB2 for Windows NT Version 2, DB2 Universal Database Server V5 for AIX/6000, Sun Solaris, and Windows NT, each produced by IBM, Oracle 7.1, 7.2, 7.3 and 80 produced by Oracle Corporation, Sybase System 10 and System 11 produced by Sybase, Inc., SQLServer 4.3 and 6.5 by Microsoft, Informix 5.0, 7.1 and 7.2 produced by Informix Corporation, and others. Object-oriented applications, such as application 104, access the data in the object-oriented DBMS 110. Such access is performed in a well-known manager according to a well-known object-oriented database interface. The object-oriented database interface conforms to the object-oriented database schema of the DMBS 110.

[0029] Application 104 accesses data in the RDBMS 112 via a Persistent Object Service (POS) 106 as will be described in more detail below. The Persistent Object Service 106 includes a schema mapping module 108 that maps objects to relational data and vice versa. The Service also includes an object store routine 107 and an object restore routine 109 for the reasons described below.

[0030] In one embodiment, the object-oriented computing environment 102 exists in a computer system 202 as shown in FIG. 2. The computer system 202 includes one or more processors, such as processor 204, which is connected to a communication bus 206. The computer system also includes a main memory 208, preferably random access memory (RAM), and a secondary memory 210 that includes, for example, a hard disk drive 212 and a floppy disk drive 214.

[0031] The application 104, POS 106, schema mapping module 108, object-oriented DBMS 110, and RDBMS 112 preferably comprise computer programs that reside during run-time in the main memory 208 and that are executed by the processors in the computer system 202, such as processor 204. The data maintained by the object-oriented DBMS 110 and the RDBMS 112 may be stored in the main memory 208 and/or the secondary memory 210. Also, the computer programs associated with the application 104, POS 106, schema mapping module 108, object-oriented DBMS 110 and RDBMS 112 may be stored in a floppy disk 218 or some other removable storage medium.

[0032] A representative computer is the well-known RISC System/6000 family of computers produced by IBM running the AIX operating system. Alternatively, the computer comprises an x86 or Pentium class processor and a Microsoft NT or UNIX platform (e.g., AIX, SunOS, Solaris, HP-UX) operating system.

[0033] POS 106 and the schema mapping module 118, when executed, enable the computer system 202 to perform the functions of the present invention as discussed herein.

[0034] Although not illustrated in detail, one of ordinary skill in the art will appreciate that the present invention may also be implemented in a distributed object operating environment over computers interconnected by a network. In this environment, distributed objects may be object clients or servers depending on whether they are sending requests to other objects or replying to requests from clients. In a distributed object environment, as is well-known, requests and replies are made through an object request broker (ORB) that is aware of the location and status of the objects. One architecture that is suitable for implementing an ORB is described in the Common Object Request Broker Architecture (CORBA) specification.

[0035] With the above as background, the present invention can now be described. As noted above, the Persistent Object Service 106 is implemented to support the ability to interface a given object with all major relational databases including, for example, DB2, Oracle, Sybase, SQL Server and Informix. Generally, POS 106 maps persistent objects to relational database tables, and it converts persistent object operations to a sequence of Structured Query Language (SQL) statements to enable persistent object data to be stored and then recalled from the relational database. A persistent object is an object whose state may outlive the life of a specific instance of the object. Relational databases typically are not designed to store data in a format in which object state is described. Thus, POS 106 provides a complete DBMS-independent object-oriented wrapper around the relational database.

[0036] As noted above, POS 106 includes a schema mapping module 108 for mapping objects to relational tables. This process is illustrated in more detail in FIG. 3. The schema mapping module receives input data, preferably information from a text-based .ini file. Alternatively, an object can be defined in any convenient data structure or format. Generally, each object 300 is mapped to one or more tables 302 a-302 n in the relational database (RDBMS) based on its attribute types and its relationships with other objects.

[0037] For attributes 304 that are lists of primitive types, specifically lists of strings, lists of integers, lists of floats, and the like, the schema mapping module maps such attributes to implicit RDBMS tables 306 a-306 n. Preferably, each attribute is mapped using an internal name (e.g., a mangled name) that is generated by and known only to POS. For attributes 308 that are of type Datetime, the schema mapping module maps to two columns 310 a-b of type date and time. For attributes 312 that contain a list of other objects by value, the schema mapping module adds two extra columns 314 a-b to a contained object table 316. For attributes 318 that contain a list of other objects by reference, the schema mapping module creates implicit relationship RDBMS tables 320 a-320 n. The schema mapping module maps other types of attributes, i.e. those not mentioned above, to single columns in a table 322 as illustrated in FIG. 4. The particular column layout and format is merely representative.

[0038] As is well-known, a given object may inherit from another object, referred to as a parent object. The schema mapping module also provides inheritance object-to-table mapping. Referring back to FIG. 3, for a given inherited object 323, the schema mapping module 108 creates multiple tables: a top level table 324 that has the base attributes 326 of the parent object, and one or more child tables 328 a-328 n that preferably contain only the extended attributes 330 of the inherited objects. An extended attribute is any additional attribute that further describes the specialization of a given class.

[0039] The following example illustrates the operation of the schema mapping module in more detail. Reference should also be made to FIG. 5. The objects are defined in an ini file in a well-known manner. In this example, there are three objects: OBJECT_A 500, OBJECT_B 502 and OBJECT_C 504, and one relationship object MREL00A01400C3FF 506. OBJECT_A 500 has four (4) attributes 508 a-d: id-type Integer, name-String, carList list of strings, and startTime-DateTime:

[0040] [OBJECT_A]

[0041] id=1

[0042] name=OBJECT_A

[0043] associd=−1

[0044] isA=

[0045] baseAttrCount=3

[0046] baseattr0=Id

[0047] baseattr1=Name

[0048] baseattr2=CarList

[0049] baseattr3=StartTime

[0050] extendedAttrCount=0

[0051] [OBJECT_A.id]

[0052] id=0

[0053] name-Name

[0054] pdsName=Name

[0055] pdsName2=

[0056] selectMask=536870920

[0057] attrMask=0

[0058] typeId=8

[0059] contTypeId=0

[0060] contObjTypeId=0

[0061] fkAttrId=0

[0062] max_string_length=0

[0063] nullable=1

[0064] [OBJECT_A.Name]

[0065] id=1

[0066] name=Name

[0067] pdsName=Name

[0068] pdsName2=

[0069] selectMask=536870912

[0070] attrMask=0

[0071] typeId=8

[0072] contTypeId=0

[0073] contObjTypeId=0

[0074] fkAttrId=0

[0075] max_string_length=0

[0076] nullable=1

[0077] [OBJECT_A.CarList]

[0078] id=2

[0079] name=CarList

[0080] pdsName=CarList

[0081] pdsName2=

[0082] selectMask=536870912

[0083] attrMask=0

[0084] typeId=12

[0085] contTypeId=8

[0086] contObjTypeId=0

[0087] fkAttrId=0

[0088] max_string_length=0

[0089] nullable=1

[0090] [OBJECT_A.StartTime]

[0091] id=3

[0092] name=StartTime

[0093] pdsName=StartDate

[0094] pdsName2=StartTime

[0095] selectMask=536870912

[0096] attrMask=0

[0097] typeId=4

[0098] contTypeId=0

[0099] contObjTypeId=0

[0100] fkAttrId=0

[0101] max_string_length=0

[0102] nullable=1

[0103] In this illustrative example, OBJECT-B 502 inherits from OBJECT_A 500 and has two (2) attributes 510 a-510 b: B_UniqAttr—type Integer, and ContCByRef—contains list of OBJECT-C by reference:

[0104] [OBJECT_B]

[0105] id=2

[0106] name=OBJECT_B

[0107] associd=−1

[0108] isA=1

[0109] baseAttrCount=2

[0110] baseattr0=Id

[0111] baseattr1=ContCByRef

[0112] extendedAttrCount=0

[0113] [OBJECT_B.id]

[0114] id=0

[0115] name=Id

[0116] pdsName=Id

[0117] pdsName2=

[0118] selectMask=536870920

[0119] attrMask=0

[0120] typeId=4

[0121] contTypeId=0

[0122] contObjTypeId=0

[0123] fkAttrId=0

[0124] max_string_length=0

[0125] nullable=0

[0126] [OBJECT_B.contCByRef]

[0127] id=1

[0128] name=contCByRef

[0129] pdsName=contCByRef

[0130] pdsName2=

[0131] selectMask=536870912

[0132] attrMask=0

[0133] typeId=12

[0134] contTypeId=11

[0135] contObjTypeId=3

[0136] fkAttrId=0

[0137] max_string_length=0

[0138] nullable=1

[0139] OBJECT-C 504 also has two (2) attributes 512 a-b: id-type Integer, and ContAByValue—contains list of OBJECT-A by value:

[0140] [OBJECT_C]

[0141] id=3

[0142] name=OBJECT_C

[0143] associd=−1

[0144] isA=1

[0145] baseAttrCount=2

[0146] baseattr0=Id

[0147] baseattr1=ContAByVal

[0148] extendedAttrCount=0

[0149] [OBJECT_C.id]

[0150] id=1

[0151] name=Id

[0152] pdsName=Id

[0153] pdsName2=

[0154] selectMask=536870912

[0155] attrMask=0

[0156] typeId=4

[0157] contTypeId=

[0158] contObjTypeId=

[0159] fkAttrId=0

[0160] max_string_length=0

[0161] nullable=0

[0162] [OBJECT_C.contAByVal]

[0163] id=1

[0164] name=contAByVal

[0165] pdsName=contAByVal

[0166] pdsName2=

[0167] selectMask=536870912

[0168] attrMask=0

[0169] typeId=12

[0170] contTypeId=10

[0171] contObjTypeId=1

[0172] fkAttrId=0

[0173] max_string_length=0

[0174] nullable=1

[0175] Finally, in this example, the relationship object 506 has three (3) attributes 514 a-c:

[0176] [MREL00A01400C3FF]

[0177] id=4

[0178] name=MREL00A01400C3FF

[0179] assocID=−1

[0180] isA=−1

[0181] baseAttrCount=3

[0182] baseattr0=PK

[0183] baseattr1=PK_A

[0184] baseattr2=PK_B

[0185] extendedAttrCount=0

[0186] ExplicitName=

[0187] A-id=2

[0188] B_id=3

[0189] [MREL00A01400C3FF.PK]

[0190] id=0

[0191] name=PK

[0192] pdsName=PK

[0193] pdsName2=

[0194] selectMask=536870920

[0195] attrMask=0

[0196] typeId=4

[0197] contTypeId=0

[0198] contObjTypeId=0

[0199] fkAttrId=0

[0200] max_string_length=0

[0201] nullable=1

[0202] [MREL00A01400C3FF.PK_A]

[0203] id=1

[0204] name=PK_A

[0205] pdsName=PK_A

[0206] pdsName2=

[0207] selectMask=536870912

[0208] attrMask=0

[0209] typeId=4

[0210] contTypeId=0

[0211] contObjTypeId=0

[0212] fkAttrId=0

[0213] max_string_length=0

[0214] nullable=1

[0215] [MREL00A01400C3FF.PK_B]

[0216] id=2

[0217] name=PK_B

[0218] pdsName=PK_B

[0219] pdsName2=

[0220] selectMask=536870912

[0221] attrMask=0

[0222] typeId=4

[0223] contTypeId=0

[0224] contObjTypeId=0

[0225] fkAttrId=0

[0226] max_string_length=0

[0227] nullable=1

[0228] As described above, the POS 106 and, in particular, the schema mapping module 108, maps the objects to relational tables as follows. As is well-known, a table includes a set of rows spanning several columns. Each column in a table includes restrictions on the data contents thereof and may be designated as a primary or foreign key. For instance, one or more columns in a base table may be assigned a key attribute, such as primary key or foreign key. The primary key of a base table uniquely identifies each record or row in the table. The foreign key of a base table establishes a relationship between the base table and another parent table designated by the foreign key column attribute. Thus, a parent/child relationship may be established between two tables by adding a foreign key column attribute to one and relating it to the primary key column attribute in another, as is well-known in the art. For more information, reference is made to C. J. Date, An Introduction To Database Systems, 6^(th) Edition, Addison-Wesley Publishing Co., Reading, Mass. (1994), for a comprehensive general treatment of the relational database art.

[0229] Because OBJECT_A is contained by OBJECT_C by value, the schema mapping module first adds foreign key field TSM_FK_FIELD and CONT_ATTR_INDEX. Object_A is then mapped to table OBJECT_A 516 (Id INT, Name varchar(254), startDate DATE, starTime varchar(8), TSM_FK_FIELD NUMBER(10), CONT_ATTR_INDEX NUMBER (5)), and a table 518 is generated for the carList attribute: SA_(—)8_(—)1_(—)2(SA_PK NUMBER(10), SA_FK NUMBER(10), SA_DATA VARCHAR2(2000)). OBJECT_B inherits from OBJECT_A, and thus it is mapped to table OBJECT-B 520 (B_UniqAttr NUMBER(10)). OBJECT_C is mapped to table OBJECT_C 522 (Id NUMBER(10)). The relationship object MREL00A01400C3FF is mapped to TABLE MREL00A01400C3FF 524 (PK NUMBER(10), PK_A NUMBER(10), PK_B NUMBER (10)). Finally, the schema mapping module performs an ALTER TABLE MREL00A01400C3FF ADD CONSTRAINT CONS_MREL00A01400C3FF UNIQUE (PK_A, PK_B) to guarantee the uniqueness of the relationship pair.

[0230] The Persistent Object Service 106 also includes a routine 107 for storing an object in the relational database, and a routine 109 for restoring an object from information retrieved from that database. These routines are described in the flowcharts of FIGS. 6-7.

[0231] The store object method of FIG. 6 begins at step 600 with the POS 106 receiving an object to be stored in the relational database. The object is preferably received from the application in stream format. At step 602, POS 106 calls the object store routine 107. At step 604, the object store routine extracts object information from the stream based on an agreed protocol. The routine then continues at step 606 to construct an “INSERT into . . . ” SQL statement.

[0232] By way of brief background, an SQL INSERT statement inserts a new row or record into a table. When a new row is inserted into a child table, its foreign key value must match one of the primary key values in a parent table, according to the column attribute. If the foreign key value does not match any primary key, inserting the row corrupts the database because there is now a child without a parent. Such an INSERT is typically rejected by the RDBMS. Inserting a row in a parent table never gives this problem because it simply becomes a parent without children. Updating the foreign key in a child record is a different form of this problem. If the foreign key is modified by an SQL UPDATE statement, the new value must match some primary key value in the parent table to avoid orphaning the updated record. For each parent/child relationship created by a foreign key, SQL provides for an associated delete rule and an associated update rule. The delete rule specifies an action, e.g., RESTRICT, CASCADE, NULL SET and SET DEFAULT, when a users tries to delete a parent record. The update rule specifies one of these actions when a user tries to update the value of one of the primary key columns in the parent table.

[0233] Referring now back to FIG. 6, after the object store routine generates the INSERT statement, the command is sent to the relational database. This is step 608. A test is then performed at step 610 to determine if the statement fails, e.g., due to a unique constraint violation. If not, the routine branches to step 612 to store the information according to the INSERT statement. If, however, the INSERT statement fails at step 610, the routine continues at step 614. At this point, the routine constructs an “UPDATE . . . ” SQL statement. At step 616, the UPDATE statement is sent to the database. The object information is then stored according to the UPDATE statement at step 618. This completes the processing for the object itself.

[0234] In the illustrative flowchart of FIG. 6, the store object routine first generates an INSERT SQL statement followed by an UPDATE SQL statement (in the event the INSERT statement fails). This sequence is not a limitation of the present invention. Alternatively, the store object routine may first generate an UPDATE SQL statement and then generate an INSERT SQL statement in the event the UPDATE statement fails. In either case, the Persistent Object Service hides from the programmer's point of view whether an explicit INSERT or UPDATE is required to write given data to a given relational table.

[0235] Following the processing illustrated in FIG. 6, the object's attributes must then be processed and stored in a like manner. The object store routine is then repeated for each type of attribute. In particular, if the object has attributes of list data type (e.g., lists of strings, lists of integers, lists of floats, and the like), the object store routine 107 performs a corresponding INSERT/UPDATE function (as previously described) on the implicit RDBMS list tables. If the object has attributes that contain a list of another object by value, the object store routine INSERTS/UPDATES the corresponding contained object tables. If the object has attributes that contain a list of another object by reference, the object store routine Inserts/Updates the implicit relationship tables correspondingly. If the object inherits from another object, the object store routine Inserts/Updates the object's ancestor(s).

[0236]FIG. 7 illustrates the object restore routine 109. This routine begins at step 700 with POS 106 receiving a restore request. At step 702, POS calls the object restore routine. Based on an object id in the restore request, the restore object routine constructs a SQL “SELECT” statement on the corresponding table. This is step 704. At step 706, the object restore routine sends the command to the relational database. At step 708, the routine tests whether all object attribute information has been retrieved. If not, the routine continues at step 710 to get the next attribute. At step 712, the attribute values are placed into the output stream. Control then returns to step 708. Thus, for example, if an attribute is a list type, the restore object routine in step 712 issues another “SELECT” on the list table. If an attribute contains another object by value, the routine in step 712 issues a “SELECT” on the corresponding table. If the attribute contains another object by reference, the restore object in step 712 issues a “SELECT” on the relationship table to get the primary key of the referenced object. When the output of the test at step 708 is positive, all attribute information has been retrieved. The object restore routine then continues at step 714 to determine whether the object inherits from another object. If so, the routine performs a join SELECT on the table and its ancestor(s) table(s). This is step 715. The routine then continues at step 716, which is also reached by a negative outcome of the test at step 714. At step 716, the object is returned to the requesting application. This completes the processing.

[0237] Thus, according to the present invention, a Persistent Object Service is implemented on top of a set of one or more relational databases, such as DB2, Oracle, Sybase, SQL Server and Informix. The Persistent Object Service maps persistent objects to relational database tables and converts persistent object operations to a sequence of SQL statements. The invention advantageously maps each object to one or more relational database tables based on the object's attributes and its relationships with other objects. For inheritance object-to-table mapping, a top level table is created for base attributes, and child tables are created that contain only the extended attributes of inherited objects.

[0238] Although the particular application of the present invention is not limited, one preferred implementation is for use in an enterprise-wide database environment of a distributed managed architecture, e.g., a Tivoli managed environment. A representative example is an enterprise that includes heterogeneous distributed database environments that must be accessed by mission-critical applications that are dependent on data stored in such databases. While such an implementation is preferred, it is not limiting. The inventive principles may be implemented whenever it is required to store object-oriented data in a relational database backing store. Thus, the principles of the invention may be carried out in an X.500 directory service or hereinafter-developed LDAP implementations.

[0239] The invention may also be implemented within a relational database management system being used as an add-on to a directory service. One of ordinary skill will appreciate that the invention can be applied to any relational database management system (RDBMS) and not simply the systems referred to above by way of example.

[0240] As described above, one of the preferred embodiments of each routine of this invention is as a set of instructions (e.g., computer program code) in a code module resident in or downloadable to the random access memory of a computer. Until required by the computer, the set of instructions may be stored in another computer memory, for example, in a hard disk drive, or in a removable memory such as an optical disk (for eventual use in a CD ROM) or floppy disk (for eventual use in a floppy disk drive), or downloaded via the Internet or other computer network.

[0241] In addition, although the various methods described are conveniently implemented in a general purpose computer selectively activated or reconfigured by software, one of ordinary skill in the art would also recognize that such methods may be carried out in hardware, in firmware, or in more specialized apparatus constructed to perform the required method steps.

[0242] Having thus described our invention, what we claim as new and desire to secure by Letters Patent is set forth in the following claims. 

What is claimed is:
 1. A method of storing object information in a relational database, comprising the steps of: extracting object information relating to an object from a stream; constructing a first SQL statement from the extracted object information; responsive to a failure of the first SQL statement, constructing a second SQL statement from the extracted object information; and storing the object information.
 2. The method as described in claim 1 wherein the first SQL statement is an insert statement and the second SQL statement is an update statement.
 3. The method as described in claim 1 wherein the first SQL statement is an update statement and the second SQL statement is an insert statement.
 4. The method as described in claim 1 wherein the first SQL statement fails if information for the object is already present in the relational database.
 5. The method as described in claim 1 wherein the object information is stored according to the first statement.
 6. The method as described in claim 1 wherein the object information is stored according to the second statement.
 7. The method as described in claim 1 wherein the object information is mapped to one or more tables in the relational database according to attributes in the object and their respective relationships with other objects.
 8. The method as described in claim 7 wherein a base table in the relational database has a set of base attributes and a set of one or more child tables related to the base table.
 9. The method as described in claim 8 wherein a given child table includes only extended attributes of inherited objects.
 10. The method as described in claim 1 wherein the relational database is one of a set of relational databases.
 11. An apparatus for storing object information in a relational database, the apparatus comprising: means for extracting object information relating to an object; means for constructing an insert statement from the extracted object information; means responsive to a failure of the insert statement for constructing an update statement from the extracted object information; and means for storing the object information.
 12. The apparatus as described in claim 11 further including means for mapping object information to one or more tables in the relational database according to attributes in the object and their respective relationships with other objects.
 13. The apparatus as described in claim 11 wherein the mapping means generates a base table in the relational database having a set of base attributes and a set of one or more child tables related to the base table.
 14. The apparatus as described in claim 13 wherein a given child table includes only extended attributes of inherited objects.
 15. A computer program product in a computer readable medium for use in a data processing system for storing object information in a relational database, the computer program product comprising: means for extracting object information relating to an object; means for constructing an insert statement from the extracted object information; means responsive to a failure of the insert statement for constructing an update statement from the extracted object information; and means for storing the object information.
 16. The computer program product as described in claim 15 further including means for mapping object information to one or more tables in the relational database according to attributes in the object and their respective relationships with other objects.
 17. The computer program product as described in claim 15 wherein the mapping means generates a base table in the relational database having a set of base attributes and a set of one or more child tables related to the base table.
 18. The computer program product as described in claim 17 wherein a given child table includes only extended attributes of inherited objects. 